package com.saver.core.business;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import android.content.Context;
import android.util.Log;

import com.saver.core.domain.Categoria;
import com.saver.core.domain.CategoriaEquiv;
import com.saver.core.domain.Establecimiento;
import com.saver.core.domain.EstablecimientoEquiv;
import com.saver.core.domain.Moneda;
import com.saver.core.domain.MonedaEquiv;
import com.saver.core.domain.Parametro;
import com.saver.core.domain.Transaccion;
import com.saver.core.exception.HTTPException;
import com.saver.core.persistence.DBManager;
import com.saver.core.persistence.RespuestaSMSRestBean;
import com.saver.core.persistence.SMSRestBean;
import com.saver.core.persistence.SMSRestService;
import com.saver.core.processor.EstadoTransaccion;
import com.saver.core.processor.TipoRegistro;
import com.saver.core.processor.Token;
import com.saver.core.processor.util.Util;
import com.saver.core.util.Constantes;

public class TransaccionCache {

	private static final String TAG = "TransaccionCache";
	private static final int NUMERO_TOKEN_PROCESO = 20;

	private Context context;
	private SMSRestService smsRestService;
	private Map<Integer, ParamTransaccion> mapParametros;
	private int numProcesados;
	
	public TransaccionCache(Context context) {
		this.context = context;
        DBManager.initialize(context);
		numProcesados = 0;
		
		this.smsRestService = new SMSRestService();
		mapParametros = new TreeMap<Integer, ParamTransaccion>(new Comparator<Integer>() {
			public int compare(Integer val1, Integer val2) {
				return val1.compareTo(val2);
			}
		});
	}
	
	public void agregarToken (Token token, Short revisado) {
		ParamTransaccion paramTransaccion = crearParamTransaccion (token, mapParametros.size() + 1, revisado);
		mapParametros.put(paramTransaccion.getId(), paramTransaccion);
		if (mapParametros.size() == NUMERO_TOKEN_PROCESO) {
			procesar ();
			numProcesados += NUMERO_TOKEN_PROCESO;
		}
	}
	
	public int finalizar () {
		int total = numProcesados + mapParametros.size();
		procesar ();
		numProcesados = 0;
		return total;
	}
	
	public Transaccion procesarToken (Token token, Short revisado) {
		ParamTransaccion paramTransaccion = crearParamTransaccion (token, 1, revisado);
		
		Transaccion transaccion = null;
		
		boolean tieneInternet = Util.tieneConexionInternet(context);
		if (tieneInternet) {
			try {
				Log.d(TAG, "UNO: Cargando por internet");
				transaccion = unoInternet(paramTransaccion);
				
			} catch (Exception e) {
				Log.d(TAG, "UNO: Error al cargar por internet, se cargara solo por local", e);
				transaccion = unoLocal(paramTransaccion);
			}
		
		// no tiene salida a internet
		} else {
			Log.d(TAG, "UNO: No tiene internet, se cargara solo por local");
			transaccion = unoLocal(paramTransaccion);
		}
		
		return transaccion;
	}
	
	private void procesar () {
		if (!mapParametros.isEmpty()) {
			// tiene salida a internet
			boolean tieneInternet = Util.tieneConexionInternet(context);
			if (tieneInternet) {
				try {
					Log.d(TAG, "LISTA: Cargando por internet");
					listaInternet();
					
				} catch (Exception e) {
					Log.d(TAG, "LISTA: Error al cargar por internet, se cargara solo por local", e);
					listaLocal();
				}
			
			// no tiene salida a internet
			} else {
				Log.d(TAG, "LISTA: No tiene internet, se cargara solo por local");
				listaLocal();
			}
		}
		
		mapParametros.clear();
	}

	private ParamTransaccion crearParamTransaccion (Token token, int id, short revisado) {
		ParamTransaccion parametros = new ParamTransaccion();
		parametros.setRevisado(revisado);
		boolean completo = true;
		Integer idBanco = token.getTipoBanco().getId();
		
		for (CategoriaEquiv ce : DBManager.categoriaEquivSQLite().buscarTodo()) {
			Log.d(TAG, ce.toString());
		}
		for (EstablecimientoEquiv ee : DBManager.establecimientoEquivSQLite().buscarTodo()) {
			Log.d(TAG, ee.toString());
		}
		
		parametros.setId(id);
		
		parametros.setIba(idBanco);
		
		String catEquiv = token.getCategoria();
		Log.d(TAG, "catEquiv: " + catEquiv);
		CategoriaEquiv categoriaEquiv = null;
		if (Util.noEsVacio(catEquiv)) {
			categoriaEquiv = DBManager.categoriaEquivSQLite().buscarPorNombre(catEquiv);
			Log.d(TAG, "categoriaEquiv encontrada: " + categoriaEquiv);
			
			// no existe la categoriaEquiv o no esta clasificado en el servidor
			if (categoriaEquiv == null || categoriaEquiv.getIdServidor() == null) {
				
				CategoriaEquiv cequiv = buscarYCrearCateEquiv(idBanco, catEquiv);
				Log.d(TAG, "cat - expr cequiv: " + cequiv);
				if (cequiv == null) {
					EstablecimientoEquiv eequiv = buscarYCrearEstabEquiv(idBanco, catEquiv);
					Log.d(TAG, "cat - expr eequiv: " + eequiv);
					
					if (eequiv != null) {
						parametros.setNee(catEquiv);
						parametros.setIee(eequiv.getIdServidor());
						Establecimiento establecimiento = DBManager.establecimientoSQLite().buscarPorId(eequiv.getIdEstablecimiento());
						parametros.setIes(establecimiento.getIdServidor());
						parametros.setIca(establecimiento.getIdCategoria());
					} else {
						parametros.setNce(catEquiv);
						completo = false;
					}
					
				} else {
					parametros.setNce(catEquiv);
					parametros.setIce(cequiv.getIdServidor());
					parametros.setIca(cequiv.getIdCategoria());
				}
				
			} else if (categoriaEquiv.getIdCategoria() == null) {
				parametros.setIce(categoriaEquiv.getIdServidor());
				completo = false;
				
			} else {
				parametros.setIce(categoriaEquiv.getIdServidor());
				parametros.setIca(categoriaEquiv.getIdCategoria());
			}
		}

		String estEquiv = token.getEstablecimiento();
		Log.d(TAG, "estEquiv: " + estEquiv);
		EstablecimientoEquiv establecimientoEquiv = null;
		if (!Util.esVacio(estEquiv)) {
			establecimientoEquiv = DBManager.establecimientoEquivSQLite().buscarPorNombre(estEquiv);
			Log.d(TAG, "establecimientoEquiv encontrado: " + establecimientoEquiv);

			// no existe el establecimientoEquiv o no esta clasificado en el servidor
			if (establecimientoEquiv == null || establecimientoEquiv.getIdServidor() == null) {
				
				CategoriaEquiv cequiv = buscarYCrearCateEquiv(idBanco, estEquiv);
				Log.d(TAG, "est - expr cequiv: " + cequiv);
				if (cequiv == null) {
					EstablecimientoEquiv eequiv = buscarYCrearEstabEquiv(idBanco, estEquiv);
					Log.d(TAG, "est - expr eequiv: " + eequiv);
					
					parametros.setNee(estEquiv);
					
					if (eequiv != null) {
						parametros.setIee(eequiv.getIdServidor());
						Establecimiento establecimiento = DBManager.establecimientoSQLite().buscarPorId(eequiv.getIdEstablecimiento());
						parametros.setIes(establecimiento.getIdServidor());
						parametros.setIca(establecimiento.getIdCategoria());
					} else {
						completo = false;
					}
					
				} else {
					parametros.setNce(estEquiv);
					parametros.setIce(cequiv.getIdServidor());
					parametros.setIca(cequiv.getIdCategoria());
				}
				
			} else if (establecimientoEquiv.getIdEstablecimiento() == null) {
				parametros.setIee(establecimientoEquiv.getIdServidor());
				completo = false;
				
			} else {
//				Integer idEstabl = establecimientoEquiv.getIdEstablecimiento();
//				parametros.setIee(establecimientoEquiv.getIdServidor());
//				parametros.setIes(idEstabl);
//				Establecimiento establecimiento = DBManager.establecimientoSQLite().buscarPorId(idEstabl);
//				parametros.setIca(establecimiento.getIdCategoria());
				
				Integer idEstabl = establecimientoEquiv.getIdEstablecimiento();
				Establecimiento establecimiento = DBManager.establecimientoSQLite().buscarPorId(idEstabl);
				parametros.setIee(establecimientoEquiv.getIdServidor());
				parametros.setIes(establecimiento.getIdServidor());
				parametros.setIca(establecimiento.getIdCategoria());
			}
		} 
		
		if (parametros.getIca() == null) {
			completo = false;
		}

		String monEquiv = token.getMoneda();
		Log.d(TAG, "monEquiv: " + monEquiv);
		MonedaEquiv monedaEquiv = null;
		if (!Util.esVacio(monEquiv)) {
			monedaEquiv = DBManager.monedaEquivSQLite().buscarPorNombre(monEquiv);

			// no existe la monedaEquiv o no esta clasificado
			if (monedaEquiv == null || monedaEquiv.getIdServidor() == null) {
				parametros.setNme(monEquiv);
				completo = false;
				
			} else if (monedaEquiv.getIdMoneda() == null) {
				parametros.setIme(monedaEquiv.getIdServidor());
				completo = false;
				
			} else {
				parametros.setIme(monedaEquiv.getIdServidor());
				parametros.setImo(monedaEquiv.getIdMoneda());
			}
		}
		
		parametros.setFsms(Util.getServiceStringToDateTime(new Date(token.getFechaSMS())));
		
		Long fechaTransaccion = token.getFechaTransaccion();
		if (fechaTransaccion == null) {
			fechaTransaccion = token.getFechaSMS();
		}
		parametros.setFtra(Util.getServiceStringToDateTime(new Date(fechaTransaccion)));
		
		parametros.setMnt(token.getImporte());
		
		parametros.setNum(token.getNumero());
		
		parametros.setCom(completo);
		
		parametros.setTip(token.getTipoToken().getId());
		
		return parametros;
	}

	private EstablecimientoEquiv buscarYCrearEstabEquiv(Integer idBanco, String nombre) {
		EstablecimientoEquiv equiv = DBManager.establecimientoEquivSQLite().buscarPorNombre(nombre);
		
		if (equiv == null) {
			for (EstablecimientoEquiv estEquivExpr : DBManager.establecimientoEquivSQLite().
					buscarTipo(Constantes.EQUIV_EXPRESION, idBanco)) {
				
				Pattern pattern = Pattern.compile(estEquivExpr.getNombre());
				Matcher matcher = pattern.matcher(nombre);
				if (matcher.find()) {
					equiv = new EstablecimientoEquiv();
					equiv.setExpresion(Constantes.EQUIV_NORMAL);
					equiv.setIdBanco(estEquivExpr.getIdBanco());
					equiv.setIdEstablecimiento(estEquivExpr.getIdEstablecimiento());
					equiv.setNombre(nombre);
					DBManager.establecimientoEquivSQLite().guardar(equiv);
					break;
				}
			}
		}
		
		return equiv;
	}

	private CategoriaEquiv buscarYCrearCateEquiv (Integer idBanco, String nombre) {
		CategoriaEquiv equiv = DBManager.categoriaEquivSQLite().buscarPorNombre(nombre);
		
		if (equiv == null) {
			for (CategoriaEquiv catEquivExpr : DBManager.categoriaEquivSQLite().
					buscarTipo(Constantes.EQUIV_EXPRESION, idBanco)) {
				
				Pattern pattern = Pattern.compile(catEquivExpr.getNombre());
				Matcher matcher = pattern.matcher(nombre);
				if (matcher.find()) {
					equiv = new CategoriaEquiv ();
					equiv.setExpresion(Constantes.EQUIV_NORMAL);
					equiv.setIdBanco(catEquivExpr.getIdBanco());
					equiv.setIdCategoria(catEquivExpr.getIdCategoria());
					equiv.setNombre(nombre);
					DBManager.categoriaEquivSQLite().guardar(equiv);
					break;
				}
			}
		}
		
		return equiv;
	}

	private void listaLocal() {
		for (ParamTransaccion paramTransaccion : mapParametros.values()) {
			unoLocal (paramTransaccion);
		}
	}

	private Transaccion unoLocal (ParamTransaccion paramTransaccion) {
		Transaccion transaccion = crearTransaccionLocal(paramTransaccion);
		DBManager.transaccionSQLite().guardar(transaccion);
		return transaccion;
	}

	private Transaccion crearTransaccionLocal(ParamTransaccion paramTransaccion) {
		Transaccion transaccion = new Transaccion ();
		
		if (paramTransaccion.isCom()) {
			copiarParametros(paramTransaccion, transaccion);
			
		} else {
			agregarCategoria(paramTransaccion.getIca(), null, paramTransaccion.getIce(), 
					paramTransaccion.getNce(), transaccion, null, paramTransaccion.getIba());
			
			agregarEstablecimiento(paramTransaccion.getIes(), null, paramTransaccion.getIee(), 
					paramTransaccion.getNee(), paramTransaccion.getIca(), transaccion, null, paramTransaccion.getIba());
			
			agregarMoneda(paramTransaccion.getImo(), null, paramTransaccion.getIme(), 
					paramTransaccion.getNme(), transaccion);
		}
		
		transaccion.setIdBanco(paramTransaccion.getIba());
		transaccion.setFechaSMS(Util.getServiceDateTimeToString(paramTransaccion.getFsms()).getTime());
		long fechaTra = Util.getServiceDateTimeToString(paramTransaccion.getFtra()).getTime();
		transaccion.setFechaText(Util.getStringToDateTime(new Date(fechaTra)));
		transaccion.setFechaTransaccion(fechaTra);
		transaccion.setMonto(paramTransaccion.getMnt());
		transaccion.setNumero(paramTransaccion.getNum());
		transaccion.setRevisado(paramTransaccion.getRevisado());
		transaccion.setTipo(paramTransaccion.getTip());
		transaccion.setEstado(EstadoTransaccion.SINCRONIZADO.getValor());
		
		return transaccion;
	}

	private void copiarParametros(ParamTransaccion paramTransaccion,
			Transaccion transaccion) {
		transaccion.setIdCategoria(paramTransaccion.getIca());
		transaccion.setIdCategoriaEquiv(paramTransaccion.getIce());
		transaccion.setIdEstablecimiento(paramTransaccion.getIes());
		transaccion.setIdEstablecimientoEquiv(paramTransaccion.getIee());
		transaccion.setIdMoneda(paramTransaccion.getImo());
		transaccion.setIdMonedaEquiv(paramTransaccion.getIme());
	}

	private void listaInternet () throws IOException, HTTPException {
		RespuestaSMSRestBean respuestaSMSRestBean = validarUsuario(mapParametros.values());
		List<SMSRestBean> smsRestBeans = respuestaSMSRestBean.getListaResultado();
		
		for (SMSRestBean smsRestBean : smsRestBeans) {
			ParamTransaccion parametroTransaccion = mapParametros.get(smsRestBean.getIdObjeto());
			Transaccion transaccion = crearTansaccionInter(smsRestBean, parametroTransaccion);
			DBManager.transaccionSQLite().guardar(transaccion);
			Log.d(TAG, "idTransaccion: " + transaccion.getId());
		}
	}

	private Transaccion unoInternet (ParamTransaccion paramTransaccion) throws IOException, HTTPException {
		ArrayList<ParamTransaccion> paramTransaccions = new ArrayList<ParamTransaccion> (1);
		paramTransaccions.add(paramTransaccion);
		Log.d(TAG, "paramTransaccion:: "+ paramTransaccion);
		RespuestaSMSRestBean respuestaSMSRestBean = validarUsuario(paramTransaccions);
		List<SMSRestBean> smsRestBeans = respuestaSMSRestBean.getListaResultado();
		SMSRestBean smsRestBean = smsRestBeans.get(0);
		
		Transaccion transaccion = crearTansaccionInter(smsRestBean, paramTransaccion);
		DBManager.transaccionSQLite().guardar(transaccion);
		return transaccion;
	}

	private RespuestaSMSRestBean validarUsuario(Collection<ParamTransaccion> parametros) throws IOException,
			HTTPException {
		Parametro parametro = DBManager.parametroSQLite().buscarPorPropiedad(Constantes.PARAMETRO_CODIGO_USUARIO);
		String codigoUsuario = parametro == null ? null : parametro.getValor();
		
		Log.d(TAG, "codigoUsuario: " + codigoUsuario);
		
		RespuestaSMSRestBean respuestaSMSRestBean = smsRestService.obtenerListaDatos(codigoUsuario, parametros);
		if (Util.esVacio(codigoUsuario)) {
			Log.d(TAG, "codigoUsuario es vacio");
			
			codigoUsuario = respuestaSMSRestBean.getCodigoUsuario();
			parametro = new Parametro();
			parametro.setPropiedad(Constantes.PARAMETRO_CODIGO_USUARIO);
			parametro.setValor(codigoUsuario);
			DBManager.parametroSQLite().guardar(parametro);
			
			Log.d(TAG, "se obtiene un codigoUsuario: " + codigoUsuario);
		}
		return respuestaSMSRestBean;
	}

	private Transaccion crearTansaccionInter(SMSRestBean smsRestBean, ParamTransaccion parametro) {
		Transaccion transaccion = new Transaccion ();
		
		if (parametro.isCom()) {
			copiarParametros(parametro, transaccion);
			
		} else {
			Integer idCategoria = smsRestBean.getIdCategoria ();
			String nombreCategoria = smsRestBean.getNombreCategoria();
			Integer idCategoriaServ = smsRestBean.getIdCategoriaServ ();
			String catEquiv = null;
			if (Constantes.RPTA_ESTABLECIMIENTO_A_CATEGORIA.equals(smsRestBean.getCambio())) {
				catEquiv = parametro.getNee();
			} else {
				catEquiv = parametro.getNce();
			}
			
			agregarCategoria(idCategoria, nombreCategoria, idCategoriaServ, catEquiv, 
					transaccion, smsRestBean.getExpresion(), parametro.getIba());
	
			Integer idEstablecimiento = smsRestBean.getIdEstablecimiento();
			String nombreEstablecimiento = smsRestBean.getNombreEstablecimiento();
			Integer idEstablecimientoServ = smsRestBean.getIdEstablecimientoServ();
			String estEquiv = null;
			if (Constantes.RPTA_CATEGORIA_A_ESTABLECIMIENTO.equals(smsRestBean.getCambio())) {
				estEquiv = parametro.getNce();
			} else {
				estEquiv = parametro.getNee();
			}
			
			agregarEstablecimiento(idEstablecimiento, nombreEstablecimiento, idEstablecimientoServ, 
					estEquiv, idCategoria, transaccion, smsRestBean.getExpresion(), parametro.getIba());
			
			Integer idMoneda = smsRestBean.getIdMoneda();
			String nombreMoneda= smsRestBean.getNombreMoneda();
			Integer idMonedaServ = smsRestBean.getIdMonedaServ();
			String monEquiv = parametro.getNme();
			
			agregarMoneda(idMoneda, nombreMoneda, idMonedaServ, monEquiv, transaccion);
			
		}

		transaccion.setFechaSMS(Util.getServiceDateTimeToString(parametro.getFsms()).getTime());
		long fechaTra = Util.getServiceDateTimeToString(parametro.getFtra()).getTime();
		transaccion.setFechaText(Util.getStringToDateTime(new Date(fechaTra)));
		transaccion.setFechaTransaccion(fechaTra);
		transaccion.setMonto(parametro.getMnt());
		transaccion.setNumero(parametro.getNum());
		transaccion.setRevisado(parametro.getRevisado());
		transaccion.setTipo(parametro.getTip());
		transaccion.setIdBanco(parametro.getIba());
		transaccion.setIdServidor(smsRestBean.getIdTransaccionServ());
		
		return transaccion;
	}

	private void agregarMoneda(Integer idMoneda, String nombreMoneda, Integer idMonedaServ,
			String monEquiv, Transaccion transaccion) {
		
		if (idMoneda != null) {
			Moneda moneda = DBManager.monedaSQLite().buscarPorId(idMoneda);
			
			if (moneda == null) {
				moneda = new Moneda();
				moneda.setId(idMoneda);
				moneda.setNombre(nombreMoneda);
				DBManager.monedaSQLite().guardar(moneda);
				
			} else {
				moneda.setNombre(nombreMoneda);
				DBManager.monedaSQLite().actualizar(moneda);
			}
			
			transaccion.setIdMoneda(idMoneda);
		}
		
		if (idMonedaServ != null) {
			MonedaEquiv monedaEquiv = DBManager.monedaEquivSQLite().buscarPorNombre(monEquiv);
			
			if (monedaEquiv == null) {
				monedaEquiv = new MonedaEquiv();
				monedaEquiv.setNombre(monEquiv);
				monedaEquiv.setIdMoneda(idMoneda);
				monedaEquiv.setIdServidor(idMonedaServ);
				DBManager.monedaEquivSQLite().guardar(monedaEquiv);
				
			} else {
				monedaEquiv.setIdMoneda(idMoneda);
				monedaEquiv.setIdServidor(idMonedaServ);
				DBManager.monedaEquivSQLite().actualizar(monedaEquiv);
			}
			
			transaccion.setIdMonedaEquiv(monedaEquiv.getId());
		}
	}

	private void agregarEstablecimiento(Integer idEstablecimiento, String nombreEstablecimiento, Integer idEstablecimientoServ,
			String estEquiv, Integer idCategoria, Transaccion transaccion, String expresion, Integer idBanco) {
		
		Integer idEstabGenerado = null;
		
		if (idEstablecimiento != null) {
//			Establecimiento establecimiento = DBManager.establecimientoSQLite().buscarPorId(idEstablecimiento);
			Establecimiento establecimiento = DBManager.establecimientoSQLite().buscarPorIdServidor(idEstablecimiento);
			
			if (establecimiento == null) {
				establecimiento = new Establecimiento();
//				establecimiento.setIdEstablecimiento(idEstablecimiento);
				establecimiento.setIdServidor(idEstablecimiento);
				establecimiento.setNombre(nombreEstablecimiento);
				establecimiento.setIdCategoria(idCategoria);
				establecimiento.setTipo(TipoRegistro.SISTEMA.getValor());
				DBManager.establecimientoSQLite().guardar(establecimiento);
				
			} else if (nombreEstablecimiento != null) {
				establecimiento.setNombre(nombreEstablecimiento);
				establecimiento.setIdCategoria(idCategoria);
				establecimiento.setTipo(TipoRegistro.SISTEMA.getValor());
				DBManager.establecimientoSQLite().actualizar(establecimiento);
			}
			
//			transaccion.setIdEstablecimiento(idEstablecimiento);

			idEstabGenerado = establecimiento.getIdEstablecimiento();
			transaccion.setIdEstablecimiento(idEstabGenerado);
			guaradarEstabEquivExpr (expresion, idEstabGenerado, idBanco);
		}
		
		if (idEstablecimientoServ != null) {
			EstablecimientoEquiv establecimientoEquiv = DBManager.establecimientoEquivSQLite().buscarPorIdServ(idEstablecimientoServ);
			
			if (establecimientoEquiv == null) {
				establecimientoEquiv = new EstablecimientoEquiv();
				establecimientoEquiv.setNombre(estEquiv);
//				establecimientoEquiv.setIdEstablecimiento(idEstablecimiento);
				establecimientoEquiv.setIdEstablecimiento(idEstabGenerado);
				establecimientoEquiv.setIdServidor(idEstablecimientoServ);
				establecimientoEquiv.setExpresion(Constantes.EQUIV_NORMAL);
				establecimientoEquiv.setIdBanco(idBanco);
				DBManager.establecimientoEquivSQLite().guardar(establecimientoEquiv);
				
			} else {
				establecimientoEquiv.setIdEstablecimiento(idEstabGenerado);
				establecimientoEquiv.setIdServidor(idEstablecimientoServ);
				establecimientoEquiv.setExpresion(Constantes.EQUIV_NORMAL);
				establecimientoEquiv.setIdBanco(idBanco);
				DBManager.establecimientoEquivSQLite().actualizar(establecimientoEquiv);
			}

			transaccion.setIdEstablecimientoEquiv(establecimientoEquiv.getId());
		}
	}

	private void agregarCategoria(Integer idCategoria, String nombreCategoria,
			Integer idCategoriaServ, String catEquiv, Transaccion transaccion, String expresion, Integer idBanco) {
		
		if (idCategoria != null) {
			Categoria categoria = DBManager.categoriaSQLite().buscarPorId(idCategoria);
			
			if (categoria == null) {
				categoria = new Categoria ();
				//categoria.setIcono(icono)
				categoria.setId(idCategoria);
				categoria.setNombre(nombreCategoria);
				DBManager.categoriaSQLite().guardar(categoria);
				
			} else if (nombreCategoria != null) {
				//categoria.setIcono(icono)
				categoria.setId(idCategoria);
				categoria.setNombre(nombreCategoria);
				DBManager.categoriaSQLite().actualizar(categoria);
			}
			
			transaccion.setIdCategoria(idCategoria);
			guaradarCateEquivExpr (expresion, idCategoria, idBanco);
			
		} else {
			transaccion.setIdCategoria(Constantes.SIN_CATEGORIZAR);
		}
		
		if (idCategoriaServ != null) {
			CategoriaEquiv categoriaEquiv = DBManager.categoriaEquivSQLite().buscarPorIdServ(idCategoriaServ);
			
			if (categoriaEquiv == null) {
				categoriaEquiv = new CategoriaEquiv();
				categoriaEquiv.setNombre(catEquiv);
				categoriaEquiv.setIdServidor(idCategoriaServ);
				categoriaEquiv.setIdCategoria(idCategoria);
				categoriaEquiv.setExpresion(Constantes.EQUIV_NORMAL);
				categoriaEquiv.setIdBanco(idBanco);
				DBManager.categoriaEquivSQLite().guardar(categoriaEquiv);
				
			} else {
				categoriaEquiv.setIdServidor(idCategoriaServ);
				categoriaEquiv.setIdCategoria(idCategoria);
				categoriaEquiv.setExpresion(Constantes.EQUIV_NORMAL);
				categoriaEquiv.setIdBanco(idBanco);
				DBManager.categoriaEquivSQLite().actualizar(categoriaEquiv);
			}
			
			transaccion.setIdCategoriaEquiv(categoriaEquiv.getId());
		}
	}
	
	private void guaradarCateEquivExpr (String nombre, Integer idCategoria, Integer idBanco) {
		if (Util.noEsVacio(nombre)) {
			CategoriaEquiv categoriaEquiv = DBManager.categoriaEquivSQLite().buscarPorNombre(nombre);
			if (categoriaEquiv == null) {
				categoriaEquiv = new CategoriaEquiv ();
				categoriaEquiv.setIdCategoria(idCategoria);
				categoriaEquiv.setNombre(nombre);
				categoriaEquiv.setExpresion(Constantes.EQUIV_EXPRESION);
				categoriaEquiv.setIdBanco(idBanco);
				DBManager.categoriaEquivSQLite().guardar(categoriaEquiv);
				
			} else {
				categoriaEquiv.setIdCategoria(idCategoria);
				categoriaEquiv.setExpresion(Constantes.EQUIV_EXPRESION);
				categoriaEquiv.setIdBanco(idBanco);
				DBManager.categoriaEquivSQLite().actualizar(categoriaEquiv);
			}
		}
	}
	
	private void guaradarEstabEquivExpr (String nombre, Integer idEstablecimiento, Integer idBanco) {
		if (Util.noEsVacio(nombre)) {
			EstablecimientoEquiv establecimientoEquiv = DBManager.establecimientoEquivSQLite().buscarPorNombre(nombre);
			if (establecimientoEquiv == null) {
				establecimientoEquiv = new EstablecimientoEquiv ();
				establecimientoEquiv.setIdEstablecimiento(idEstablecimiento);
				establecimientoEquiv.setNombre(nombre);
				establecimientoEquiv.setExpresion(Constantes.EQUIV_EXPRESION);
				establecimientoEquiv.setIdBanco(idBanco);
				DBManager.establecimientoEquivSQLite().guardar(establecimientoEquiv);
				
			} else {
				establecimientoEquiv.setIdEstablecimiento(idEstablecimiento);
				establecimientoEquiv.setExpresion(Constantes.EQUIV_EXPRESION);
				establecimientoEquiv.setIdBanco(idBanco);
				DBManager.establecimientoEquivSQLite().actualizar(establecimientoEquiv);
			}
		}
	}

}
